/**
 * @p.md
 * 
 * DefaultMailbox 模块，提供 Actor 消息队列的默认实现
 */
import { Mailbox, MessageQueue } from './mailbox';
import { MessageInvoker } from './messageInvoker';
import { Dispatcher } from './dispatcher';

/**
 * 默认邮箱实现，处理 Actor 的消息队列
 */
export class DefaultMailbox implements Mailbox {
  // 用户消息队列
  private readonly _userMailbox: MessageQueue;
  // 系统消息队列
  private readonly _systemMailbox: MessageQueue;
  // 消息调用者
  private _invoker?: MessageInvoker;
  // 调度器
  private _dispatcher?: Dispatcher;
  // 是否正在处理
  private _processing: boolean = false;
  // 是否已暂停
  private _suspended: boolean = false;
  
  /**
   * 创建默认邮箱
   * @param userMailbox 用户消息队列
   * @param systemMailbox 系统消息队列
   */
  constructor(userMailbox: MessageQueue, systemMailbox: MessageQueue) {
    this._userMailbox = userMailbox;
    this._systemMailbox = systemMailbox;
  }
  
  /**
   * 投递用户消息
   * @param message 用户消息
   */
  postMessage(message: any): void {
    this._userMailbox.enqueue(message);
    this.schedule();
  }
  
  /**
   * 投递系统消息
   * @param message 系统消息
   */
  postSystemMessage(message: any): void {
    this._systemMailbox.enqueue(message);
    this.schedule();
  }
  
  /**
   * 启动邮箱处理
   */
  start(): void {
    // 默认邮箱不需要特殊启动逻辑
  }
  
  /**
   * 注册处理器和调度器
   * @param invoker 消息调用者
   * @param dispatcher 调度器
   */
  registerHandlers(invoker: MessageInvoker, dispatcher: Dispatcher): void {
    this._invoker = invoker;
    this._dispatcher = dispatcher;
  }
  
  /**
   * 调度消息处理
   */
  private schedule(): void {
    if (this._suspended) {
      return;
    }
    
    if (this._processing) {
      return;
    }
    
    if (!this._dispatcher) {
      throw new Error('Mailbox dispatcher not set');
    }
    
    if (!this._invoker) {
      throw new Error('Mailbox invoker not set');
    }
    
    this._processing = true;
    this._dispatcher.schedule(this.processMessages.bind(this));
  }
  
  /**
   * 处理消息
   */
  private processMessages(): void {
    if (this._suspended) {
      this._processing = false;
      return;
    }
    
    if (!this._invoker) {
      this._processing = false;
      throw new Error('Message invoker not set');
    }
    
    // 处理所有系统消息
    this.processSystemMessages();
    
    // 如果处理系统消息后被暂停，不继续处理用户消息
    if (this._suspended) {
      this._processing = false;
      return;
    }
    
    // 处理用户消息
    this.processUserMessages();
    
    // 如果两个队列都为空，停止处理
    if (this._systemMailbox.isEmpty() && this._userMailbox.isEmpty()) {
      this._processing = false;
      return;
    }
    
    // 有更多消息，继续调度
    if (this._dispatcher) {
      this._dispatcher.schedule(this.processMessages.bind(this));
    }
  }
  
  /**
   * 处理系统消息
   */
  private processSystemMessages(): void {
    while (!this._systemMailbox.isEmpty() && !this._suspended && this._invoker) {
      const msg = this._systemMailbox.dequeue();
      if (msg !== undefined) {
        this._invoker.invokeSystemMessage(msg);
      }
    }
  }
  
  /**
   * 处理用户消息
   */
  private processUserMessages(): void {
    // 获取吞吐量限制
    const throughput = this._dispatcher ? this._dispatcher.throughput() : 300;
    
    // 处理用户消息，但不超过吞吐量限制
    let processedCount = 0;
    while (!this._userMailbox.isEmpty() && !this._suspended && this._invoker && processedCount < throughput) {
      const msg = this._userMailbox.dequeue();
      if (msg !== undefined) {
        this._invoker.invokeUserMessage(msg);
        processedCount++;
      }
    }
  }
  
  /**
   * 暂停邮箱处理
   */
  suspend(): void {
    this._suspended = true;
  }
  
  /**
   * 恢复邮箱处理
   */
  resume(): void {
    this._suspended = false;
    this.schedule();
  }
  
  /**
   * 获取用户消息队列长度
   */
  userMessageCount(): number {
    return this._userMailbox.length();
  }
  
  /**
   * 获取系统消息队列长度
   */
  systemMessageCount(): number {
    return this._systemMailbox.length();
  }
} 